function processScanExpandMode(gCode, imageData, gcodeParams) {
    // if (gcodeParams.scanDir === 'X') {
        // processX(gCode, imageData, gcodeParams)
    // } else {
        processY(gCode, imageData, gcodeParams);
    // }
}

function processY(gCode, image, gcp) {
    let width = image.width;
    let height = image.height;
    let aSize = gcp.laserABeamSize;
    let ySize = gcp.laserYBeamSize;
    let isRelativeCoord = gcp.isRelativeCoord;

    // gcp.yOffset += ySize; // 将 y 的坐标往上调一个像素位置
    gCode.speed(0);
    gCode.rapid({a:  gcp.aOffset, y: (height - 1) * ySize + gcp.yOffset});
    
    let positionCount = 0;
    let lineCount = 0;
    let didLaserToggle = false; // 激光开关状态
    let changeLaserPower = false; // 是否需要切换激光器功率
    let powerValue = 0;
    let maxGray = gcp.maxGray; // 最大灰度值
    if (!gcp.gray255Power && maxGray === 255) maxGray -= 1; // 灰度范围为 0 - 254,, 255不打标
    let grayscale = maxGray - gcp.minGray; // 灰度范围
    let lastGrayscale = maxGray + 1; // 上一个灰度值

    let ratioLaser = (gcp.laserPowerMaxS - gcp.laserPowerMinS) / grayscale; // 计算激光器功率比例
    let lastIndex = {x: 0 , y: height - 1}; 

    let changeX2Z = false; // 是否已切换 X 轴到 Z 轴


    let direction = 0; // 前进
    let directionToggle = 1; // 方向切换
    let serpentine = gcp.serpentine; // 是否启用双向扫描
    if (serpentine) {
        directionToggle = 2;
    }

    for (let x = 0; x < width; x++) {  // 从左上角开始扫描
        direction = x % directionToggle; // 切换方向
        let start, end, step;
        if (direction === 0) {
            start = height - 1;
            end = -1;
            step = -1;
        } else {
            start = 0;
            end = height;
            step = 1;
        }

        for (let y = start; y != end; y += step) {
            let grayscale = image.data[x][y]; // 获取灰度值
            changeLaserPower = (grayscale !== lastGrayscale); // 是否需要更新激光值
            if (changeLaserPower) { // 如果上一个灰度值和当前灰度值差值大于灰度精度，则需要切换激光器功率
                didLaserToggle = true; // 这一行相较于第一个点的功率有变化

                if (positionCount !== 0) { // 如果有计数直 （即上一个功率值需要移动 positionCount 个像素点）
                    if (lineCount > 0) {
                        gCode.speed(0); // 关光
                        lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息
                        if (isRelativeCoord) {
                            // 不知道哪个版本限制的，跳转也用 G1 
                            gCode.linear({a: lineCount * aSize, y: (start - lastIndex.y) * ySize});
                            gCode.speed(powerValue);
                            gCode.linear({y: positionCount * ySize});
                        }else { 
                            gCode.linear({a: x * aSize + gcp.aOffset , y: start * ySize + gcp.yOffset}); 
                            gCode.speed(powerValue);
                            gCode.linear({y: (start + positionCount) * ySize + gcp.yOffset});
                        } 
                        lastIndex.x = x;
                        lastIndex.y = start + positionCount;
                        lineCount = 0;
                    } else {
                        if (isRelativeCoord) {
                            gCode.linear({y: positionCount * ySize}); 
                        }else {
                            gCode.linear({y: y * ySize + gcp.yOffset});
                        } 
                        lastIndex.y += positionCount;
                    }
                    positionCount = 0; // 移动完计数直归零
                }
                lastGrayscale = grayscale; // 更新灰度值信息
                powerValue = grayscale < maxGray + 1 
                            ? Math.floor(ratioLaser * (maxGray - grayscale) + gcp.laserPowerMinS)
                            : 0; // 计算新的激光器激光功率
                if(lineCount === 0) gCode.speed(powerValue); // 设置新的激光器激光功率

            }
            positionCount += step;
        }
        // 一行扫描完成，检查是否需要关闭激光器，并移动到新一行
        if (positionCount !== 0 && didLaserToggle) {
            // 移动到末尾
            if (powerValue !== 0){
                if (isRelativeCoord) {
                    gCode.linear({y: positionCount * ySize});
                }else {
                    gCode.linear({y: end  * ySize + gcp.yOffset});
                    // gCode.linear({x: end * xSize + gcp.xOffset, y: (y + 1) * ySize + gcp.yOffset});
                } 
                lastIndex.x = x;
                lastIndex.y = end;
                gCode.speed(0); // 关光
            }
            
            didLaserToggle = false;
            lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息

            // 换行
            if (direction === 0 && serpentine){ // 双向，准备换向
                if (isRelativeCoord) {
                    // 不知道哪个版本开始限制，跳转用 G1
                    gCode.linear({a: (lineCount + 1) * aSize, y: (end - lastIndex.y ) * ySize});
                }else {
                    gCode.linear({x: (x + 1) * aSize + gcp.aOffset, y: (end)  * ySize + gcp.yOffset});
                } 
                lastIndex.y = end;
            } else { // 单向，移动到新的一行的开头
                if (isRelativeCoord) {
                    gCode.linear({a: (lineCount + 1) * aSize, y: (start - lastIndex.y ) * ySize});
                }else {
                    gCode.linear({a: (x + 1) * aSize + gcp.aOffset, y: start  * ySize + gcp.yOffset});
                } 
                lastIndex.y = start;
            }
            lineCount = 0;
            lastIndex.x = x + 1;
        } else {
            lineCount++;
        }

        changeLaserPower = false;
        positionCount = 0;
    }
    gCode.laserOff(); // 关激光
    if (isRelativeCoord) { // 回零
        gCode.rapid({a: -lastIndex.x * gcp.laserABeamSizeActual - gcp.aOffset, y: -lastIndex.y * ySize - gcp.yOffset});
    }else {
        gCode.rapid({x: 0, y: 0});
    }   
}

module.exports = { processScanExpandMode };